package com.dinzeer.legendreliclib.lib.compat.curios;

import net.minecraft.nbt.CompoundTag;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.tags.ItemTags;
import net.minecraft.world.entity.EquipmentSlot;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemStack;
import net.minecraftforge.common.util.LazyOptional;
import net.minecraftforge.fml.ModList;
import top.theillusivec4.curios.api.CuriosApi;
import top.theillusivec4.curios.api.SlotResult;
import top.theillusivec4.curios.api.type.capability.ICuriosItemHandler;
import top.theillusivec4.curios.api.type.inventory.ICurioStacksHandler;

import java.util.Iterator;
import java.util.Map;
import java.util.Optional;

public class CurioCompat {
    /**
     * 检查实体是否在任何装备槽或饰品栏中持有指定物品。
     *
     * @param player 实体对象
     * @param item   要检查的物品
     * @return 如果持有返回true，否则false
     */
    public static boolean hasItemInCurioOrSlot(LivingEntity player, Item item) {
        EquipmentSlot[] var2 = EquipmentSlot.values();
        int var3 = var2.length;

        for (int var4 = 0; var4 < var3; ++var4) {
            EquipmentSlot e = var2[var4];
            if (player.getItemBySlot(e).is(item)) {
                return true;
            }
        }

        return hasItemInCurio(player, item);
    }

    /**
     * 检查实体是否在饰品栏中持有指定物品。
     *
     * @param player 实体对象
     * @param item   要检查的物品
     * @return 如果持有返回true，否则false
     */
    public static boolean hasItemInCurio(LivingEntity player, Item item) {
        return ModList.get().isLoaded("curios") ? hasItemImpl(player, item) : false;
    }

    /**
     * 实际实现检查实体是否在饰品栏中持有指定物品。
     *
     * @param player 实体对象
     * @param item   要检查的物品
     * @return 如果持有返回true，否则false
     */
    private static boolean hasItemImpl(LivingEntity player, Item item) {
        LazyOptional<ICuriosItemHandler> opt = CuriosApi.getCuriosInventory(player);
        if (opt.resolve().isEmpty()) {
            return false;
        } else {
            ItemStack stack = new ItemStack(item);
            Iterator var4 = ((ICuriosItemHandler) opt.resolve().get()).getCurios().values().iterator();

            while (true) {
                ICurioStacksHandler e;
                do {
                    do {
                        if (!var4.hasNext()) {
                            return false;
                        }

                        e = (ICurioStacksHandler) var4.next();
                    } while (e.getStacks().getSlots() == 0);
                } while (!e.getIdentifier().equals("curio") && !stack.is(ItemTags.create(new ResourceLocation("curios", e.getIdentifier()))));

                for (int i = 0; i < e.getStacks().getSlots(); ++i) {
                    if (e.getStacks().getStackInSlot(i).is(item)) {
                        return true;
                    }
                }
            }
        }
    }
    /**
     * 在饰品栏中查找指定物品。
     *
     * @param entity 实体对象
     * @param item   要查找的物品
     * @return 返回找到的物品堆栈，如果未找到返回Optional.empty()
     */
    public static Optional<ItemStack> findCurioItem(LivingEntity entity, Item item) {
        return CuriosApi.getCuriosInventory(entity)
                .resolve()
                .flatMap(inv -> inv.findFirstCurio(item))
                .map(SlotResult::stack); // 注意方法名改为getStack
    }






    /**
     * 获取玩家主手物品的Curio数据。
     *
     * @param player 玩家对象
     * @return 返回包含Curio数据的CompoundTag，如果不存在返回null
     */
    public static Optional<CompoundTag> getCurioStickData(Player player) {
        return Optional.ofNullable(player.getMainHandItem().getTag());
    }

    /**
     * 重置玩家主手物品的Curio数据。
     *
     * @param player 玩家对象
     */
    public static void resetCurioStickData(Player player) {
        CompoundTag tag = player.getMainHandItem().getOrCreateTag();
        tag.putBoolean("curiostick_attack", false);
    }








    /**
     * 在饰品栏中查找指定物品。
     *
     * @param player 玩家对象
     * @param item   要查找的物品
     * @return 返回找到的物品堆栈，如果未找到返回Optional.empty()
     */
    public static Optional<ItemStack> findFirstCurio(Player player, Item item) {
        return CuriosApi.getCuriosInventory(player)
                .resolve()
                .flatMap(inv -> inv.findFirstCurio(item))
                .map(SlotResult::stack);
    }

    /**
     * 获取玩家 ex_curio 槽位中的所有物品。
     *
     * @param player 玩家对象
     * @return 返回包含 ex_curio 槽位中所有物品的列表
     */
    public static java.util.List<Item> getExCurioItems(Player player) {
        java.util.List<Item> items = new java.util.ArrayList<>();
        if (ModList.get().isLoaded("curios")) {
            LazyOptional<ICuriosItemHandler> opt = CuriosApi.getCuriosInventory(player);
            if (opt.isPresent()) {
                ICuriosItemHandler curios = opt.resolve().get();
                for (Map.Entry<String, ICurioStacksHandler> entry : curios.getCurios().entrySet()) {
                    String identifier = entry.getKey();
                    if (identifier.equals("ex_curio")) {
                        ICurioStacksHandler handler = entry.getValue();
                        for (int i = 0; i < handler.getSlots(); i++) {
                            ItemStack stack = handler.getStacks().getStackInSlot(i);
                            if (!stack.isEmpty()) {
                                items.add(stack.getItem());
                            }
                        }
                    }
                }
            }
        }
        return items;
    }

}